package ob_TakeNote;

import ob_TakeNote.utils.SplicingAddress;

import java.io.File;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

//大家好
public class ob_main {
    /**
     * 解析一个作为目录使用md文件，将内容里关联的双链md文件，图片链接
     * 一层层全部跑出，复制到新文件夹中
     *
     * @param mdPath 作为目录使用的md文件的地址：E:\Test_ob\云仓库\专业领域\Java\Java学习索引.md
     * @param dirs   作为源ob笔记仓库下的所有路径 ：E:\\Test_ob\\云仓库
     * @param target target：存放复制后新文件夹的地址：C:\Users\86158\Desktop\ob_整理文件测试\
     */
    public void copy_obsidian(File mdPath, HashSet<File> dirs, String target) throws Exception {

        List<File> sourceFiles = new ArrayList<>();
        //
        sourceFiles.add(mdPath);

        for_obsidian(sourceFiles, target, dirs);


    }

    /**
     * 读取md文本，提取出所有双链地址，
     * 同时修改md文本内部双链，比如说[[目录/git|git]]改成[[git]]
     * <p>
     * 代码难点解释：
     * 最外层if,是处理存在[[|]],重命名的情况的。
     * 重命名分为两种情况处理：
     * 1.包含有“/”，[[../专业领域/Java/Java学习索引|Java学习索引]]
     * 2.第二种，就是纯粹的重命名：[[我是伟字号|我是阿伟]]
     * 最外层的slse,处理就是没有重命名的情况，这种类型的[[]]
     *
     * @param md 包含一个md文件里的所有文本内容
     * @return 提取的md文件里所有双链地址，“[双链地址]”，返回是列表数据
     */
    public List<String> find_mdNames(List<String> md) {
        // 创建一个新列表，用于存储提取的字符串
        List<String> extractedStrings = new ArrayList<>();
        // 创建正则表达式模式，匹配“[[任意字符|文件名]]”
        Pattern pattern = Pattern.compile("\\[\\[(.*?)\\]\\]");

        String fileName = null;
        for (int i = 0; i < md.size(); i++) {
            // 遍历md中的每一行
            String mdLine = md.get(i);

            // 匹配双链
            Matcher doubleStrandedMatcher = pattern.matcher(mdLine);
            while (doubleStrandedMatcher.find()) {
                // 获取整个匹配的内容：[[任意字符串]]
                String fullMatch = doubleStrandedMatcher.group(0); // 获取整个匹配的内容，包括方括号
                String content = doubleStrandedMatcher.group(1);   // 获取方括号内的内容

                // 判断是否存在“|”在[[]]中
                if (content.contains("|")) {
                    // 分割后的结果：[[ parts[0]|parts[1] ]]
                    String[] parts = content.split("\\|", 2);
                    if (parts[0].contains("/")) {
                        // 处理包含路径的情况
                        int index = parts[0].lastIndexOf("/");
                        fileName = parts[0].substring(index + 1);
                        if (fileName.contains("#")) {
                            int hashIndex = fileName.indexOf('#');
                            fileName = fileName.substring(0, hashIndex);
                        }
                        // 修改md文本，将[[ parts[0]|parts[1] ]]修改为[[ parts[1] ]]

                        String modifiedStr = mdLine.replace(fullMatch, "[[" + fileName + "|" + parts[1] + "]]");
                        md.set(i, modifiedStr);
                    } else if (parts[0].contains("#")) {
                        int hashIndex = parts[0].indexOf('#');
                        fileName = parts[0].substring(0, hashIndex);
                    } else {
                        fileName = parts[0];
                    }
                } else if (!content.contains(".png")) {
                    if (content.contains("/")) {
                        int index = content.lastIndexOf("/");
                        fileName = content.substring(index + 1);
                        if (fileName.contains("#")) {
                            int hashIndex = fileName.indexOf('#');
                            fileName = fileName.substring(0, hashIndex);
                        }
                        String modifiedStr = mdLine.replace(fullMatch, "[[" + fileName + "]]");
                        md.set(i, modifiedStr);
                    } else if (content.contains("#")) {
                        int hashIndex = content.indexOf('#');
                        fileName = content.substring(0, hashIndex);
                    } else {
                        fileName = content;
                    }
                } else {
                    fileName = null; // 因为这一种是图片的链接，所以赋值为null，不处理，因为前面就处理过了。
                }

                if (fileName != null) {
                    extractedStrings.add(fileName);
                }
            }
        }
        return extractedStrings;
    }
    /**
     * @param sourceFiles
     * @param target      target= c://新文件//
     * @param dirs        某个仓库下的所有路径
     *
     */
    public void for_obsidian(List<File> sourceFiles, String target, HashSet<File> dirs) throws Exception {
        if (sourceFiles == null) return;
        for (File sourceFile : sourceFiles) {
            List<String> md = Read_ob.read_md(sourceFile);
            if (md == null) continue;

            //完成图片复制。
            String targetPicturePath = target + "附件\\";
            CopyAttachments.copyAttachments(targetPicturePath, md, dirs);
            //复制md到新的文件夹中并同时找出md包含的双链地址。
            File targetPath = SplicingAddress.splicingAddress(target, sourceFile);
            List<String> extractedStrings = find_mdNames(md);
            Copy_ob.copy_ob(md, targetPath);
            //完成复制，就移除对应的路径
            dirs.remove(sourceFile);

            //递归
            if (extractedStrings == null) continue;
            List<File> sourcePaths = FilenameMatchingPath.filenameMatchingPath(extractedStrings, dirs);
            for_obsidian(sourcePaths, target, dirs);


        }


    }
}
